home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / containers / utilityClasses / Flex.as < prev    next >
Encoding:
Text File  |  2010-05-14  |  7.9 KB  |  246 lines

  1. package mx.containers.utilityClasses
  2. {
  3.    import mx.core.Container;
  4.    import mx.core.IUIComponent;
  5.    import mx.core.mx_internal;
  6.    
  7.    use namespace mx_internal;
  8.    
  9.    public class Flex
  10.    {
  11.       mx_internal static const VERSION:String = "2.0.1.0";
  12.       
  13.       public function Flex()
  14.       {
  15.          super();
  16.       }
  17.       
  18.       public static function flexChildWidthsProportionally(param1:Container, param2:Number, param3:Number) : Number
  19.       {
  20.          var _loc4_:Number = NaN;
  21.          var _loc5_:Number = NaN;
  22.          var _loc6_:Array = null;
  23.          var _loc7_:FlexChildInfo = null;
  24.          var _loc8_:IUIComponent = null;
  25.          var _loc9_:int = 0;
  26.          var _loc10_:int = 0;
  27.          var _loc11_:Number = NaN;
  28.          var _loc12_:Number = NaN;
  29.          var _loc13_:Number = NaN;
  30.          var _loc14_:Number = NaN;
  31.          _loc4_ = param2;
  32.          _loc5_ = 0;
  33.          _loc6_ = [];
  34.          _loc10_ = param1.numChildren;
  35.          _loc9_ = 0;
  36.          while(_loc9_ < _loc10_)
  37.          {
  38.             _loc8_ = IUIComponent(param1.getChildAt(_loc9_));
  39.             _loc11_ = _loc8_.percentWidth;
  40.             _loc12_ = _loc8_.percentHeight;
  41.             if(!isNaN(_loc12_) && _loc8_.includeInLayout)
  42.             {
  43.                _loc13_ = Math.max(_loc8_.minHeight,Math.min(_loc8_.maxHeight,_loc12_ >= 100 ? param3 : param3 * _loc12_ / 100));
  44.             }
  45.             else
  46.             {
  47.                _loc13_ = _loc8_.getExplicitOrMeasuredHeight();
  48.             }
  49.             if(!isNaN(_loc11_) && _loc8_.includeInLayout)
  50.             {
  51.                _loc5_ += _loc11_;
  52.                _loc7_ = new FlexChildInfo();
  53.                _loc7_.percent = _loc11_;
  54.                _loc7_.min = _loc8_.minWidth;
  55.                _loc7_.max = _loc8_.maxWidth;
  56.                _loc7_.height = _loc13_;
  57.                _loc7_.child = _loc8_;
  58.                _loc6_.push(_loc7_);
  59.             }
  60.             else
  61.             {
  62.                _loc14_ = _loc8_.getExplicitOrMeasuredWidth();
  63.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  64.                {
  65.                   _loc8_.setActualSize(Math.floor(_loc14_),Math.floor(_loc13_));
  66.                }
  67.                else
  68.                {
  69.                   _loc8_.setActualSize(_loc14_,_loc13_);
  70.                }
  71.                if(_loc8_.includeInLayout)
  72.                {
  73.                   _loc4_ -= _loc8_.width;
  74.                }
  75.             }
  76.             _loc9_++;
  77.          }
  78.          if(_loc5_)
  79.          {
  80.             _loc4_ = flexChildrenProportionally(param2,_loc4_,_loc5_,_loc6_);
  81.             _loc10_ = int(_loc6_.length);
  82.             _loc9_ = 0;
  83.             while(_loc9_ < _loc10_)
  84.             {
  85.                _loc7_ = _loc6_[_loc9_];
  86.                _loc8_ = _loc7_.child;
  87.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  88.                {
  89.                   _loc8_.setActualSize(Math.floor(_loc7_.size),Math.floor(_loc7_.height));
  90.                }
  91.                else
  92.                {
  93.                   _loc8_.setActualSize(_loc7_.size,_loc7_.height);
  94.                }
  95.                _loc9_++;
  96.             }
  97.          }
  98.          return _loc4_;
  99.       }
  100.       
  101.       public static function flexChildHeightsProportionally(param1:Container, param2:Number, param3:Number) : Number
  102.       {
  103.          var _loc4_:Number = NaN;
  104.          var _loc5_:Number = NaN;
  105.          var _loc6_:Array = null;
  106.          var _loc7_:FlexChildInfo = null;
  107.          var _loc8_:IUIComponent = null;
  108.          var _loc9_:int = 0;
  109.          var _loc10_:int = 0;
  110.          var _loc11_:Number = NaN;
  111.          var _loc12_:Number = NaN;
  112.          var _loc13_:Number = NaN;
  113.          var _loc14_:Number = NaN;
  114.          _loc4_ = param2;
  115.          _loc5_ = 0;
  116.          _loc6_ = [];
  117.          _loc10_ = param1.numChildren;
  118.          _loc9_ = 0;
  119.          while(_loc9_ < _loc10_)
  120.          {
  121.             _loc8_ = IUIComponent(param1.getChildAt(_loc9_));
  122.             _loc11_ = _loc8_.percentWidth;
  123.             _loc12_ = _loc8_.percentHeight;
  124.             if(!isNaN(_loc11_) && _loc8_.includeInLayout)
  125.             {
  126.                _loc13_ = Math.max(_loc8_.minWidth,Math.min(_loc8_.maxWidth,_loc11_ >= 100 ? param3 : param3 * _loc11_ / 100));
  127.             }
  128.             else
  129.             {
  130.                _loc13_ = _loc8_.getExplicitOrMeasuredWidth();
  131.             }
  132.             if(!isNaN(_loc12_) && _loc8_.includeInLayout)
  133.             {
  134.                _loc5_ += _loc12_;
  135.                _loc7_ = new FlexChildInfo();
  136.                _loc7_.percent = _loc12_;
  137.                _loc7_.min = _loc8_.minHeight;
  138.                _loc7_.max = _loc8_.maxHeight;
  139.                _loc7_.width = _loc13_;
  140.                _loc7_.child = _loc8_;
  141.                _loc6_.push(_loc7_);
  142.             }
  143.             else
  144.             {
  145.                _loc14_ = _loc8_.getExplicitOrMeasuredHeight();
  146.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  147.                {
  148.                   _loc8_.setActualSize(Math.floor(_loc13_),Math.floor(_loc14_));
  149.                }
  150.                else
  151.                {
  152.                   _loc8_.setActualSize(_loc13_,_loc14_);
  153.                }
  154.                if(_loc8_.includeInLayout)
  155.                {
  156.                   _loc4_ -= _loc8_.height;
  157.                }
  158.             }
  159.             _loc9_++;
  160.          }
  161.          if(_loc5_)
  162.          {
  163.             _loc4_ = flexChildrenProportionally(param2,_loc4_,_loc5_,_loc6_);
  164.             _loc10_ = int(_loc6_.length);
  165.             _loc9_ = 0;
  166.             while(_loc9_ < _loc10_)
  167.             {
  168.                _loc7_ = _loc6_[_loc9_];
  169.                _loc8_ = _loc7_.child;
  170.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  171.                {
  172.                   _loc8_.setActualSize(Math.floor(_loc7_.width),Math.floor(_loc7_.size));
  173.                }
  174.                else
  175.                {
  176.                   _loc8_.setActualSize(_loc7_.width,_loc7_.size);
  177.                }
  178.                _loc9_++;
  179.             }
  180.          }
  181.          return _loc4_;
  182.       }
  183.       
  184.       public static function flexChildrenProportionally(param1:Number, param2:Number, param3:Number, param4:Array) : Number
  185.       {
  186.          var _loc5_:int = 0;
  187.          var _loc6_:Number = NaN;
  188.          var _loc7_:Boolean = false;
  189.          var _loc8_:Number = NaN;
  190.          var _loc9_:* = undefined;
  191.          var _loc10_:* = undefined;
  192.          var _loc11_:* = undefined;
  193.          var _loc12_:* = undefined;
  194.          var _loc13_:* = undefined;
  195.          var _loc14_:* = undefined;
  196.          _loc5_ = int(param4.length);
  197.          _loc8_ = param2 - param1 * param3 / 100;
  198.          if(_loc8_ > 0)
  199.          {
  200.             param2 -= _loc8_;
  201.          }
  202.          do
  203.          {
  204.             _loc6_ = 0;
  205.             _loc7_ = true;
  206.             _loc9_ = param2 / param3;
  207.             _loc10_ = 0;
  208.             while(_loc10_ < _loc5_)
  209.             {
  210.                _loc11_ = param4[_loc10_];
  211.                _loc12_ = _loc11_.percent * _loc9_;
  212.                if(_loc12_ < _loc11_.min)
  213.                {
  214.                   _loc13_ = _loc11_.min;
  215.                   _loc11_.size = _loc13_;
  216.                   param4[_loc10_] = param4[--_loc5_];
  217.                   param4[_loc5_] = _loc11_;
  218.                   param3 -= _loc11_.percent;
  219.                   param2 -= _loc13_;
  220.                   _loc7_ = false;
  221.                   break;
  222.                }
  223.                if(_loc12_ > _loc11_.max)
  224.                {
  225.                   _loc14_ = _loc11_.max;
  226.                   _loc11_.size = _loc14_;
  227.                   param4[_loc10_] = param4[--_loc5_];
  228.                   param4[_loc5_] = _loc11_;
  229.                   param3 -= _loc11_.percent;
  230.                   param2 -= _loc14_;
  231.                   _loc7_ = false;
  232.                   break;
  233.                }
  234.                _loc11_.size = _loc12_;
  235.                _loc6_ += _loc12_;
  236.                _loc10_++;
  237.             }
  238.          }
  239.          while(!_loc7_);
  240.          
  241.          return Math.max(0,Math.floor(param2 - _loc6_));
  242.       }
  243.    }
  244. }
  245.  
  246.